const db = uniCloud.database();
const userTable = db.collection("uni-id-users")
const $ = db.command
const nowTime = new Date().getTime()

/**
 * 设置用户身份
 * @param {Object} [param0={}] 
 * @param {id} 支付用户的 id
 * @param {orderid} 用户支付是的订单编号 
 */
async function setNewLevel({
	id,
	orderid
} = {}) {

	try {
		let userArr = []
		let res = await userTable.doc(id).field({
			inviter_uid: true
		}).get() //查找用户的推荐人
		let ids = res.data[0].inviter_uid || [] //获取用户推荐人的数组

		//设置用户分润
		await setProfit({
			id,
			inviterIds: ids,
			order_no: orderid
		})

		//更新当前购买人的身份信息
		await upLevel([{
			id,
			newLevel: 1,
			upNewLevelTime: nowTime
		}])

		//没有直接推荐人
		if (ids.length == 0) {
			return
		}
		//有推荐人,循环推荐人，更新推荐人的身份
		for (let i = 0; i < ids.length; i++) {
			let upNewLevel = await getUpUser(ids[i])
			userArr.push({
				id: ids[i],
				newLevel: upNewLevel,
			})
		}

		await upLevel(userArr)
	} catch (e) {
		console.log("setNewLevel.catch=====>", e);
	}

}
/**
 * 查询推荐人的新身份信息
 * @param {id} 推荐人的id 
 */
async function getUpUser(id) {
	try {
		let res = await userTable.doc(id).field({
			newLevel: true,
		}).get()

		let newLevel = 0 //用户层级默认普通

		let level = res.data[0].newLevel || 0 //推荐人当前的等级
		//1，幸福使者  2，幸福大师 3，幸福天使  4联合创始人
		if (level >= 3) { //如果已经是最高等级，天使或者联合，直接推出，不用调整
			return level
		}
		if (level == 0) { // 如果当前用户是普通用户，直接返回
			return 0
		}
		let tUser = await userTable.where({
			'inviter_uid.0': id,
			newLevel: 1
		}).count() //查询直接推荐的使者数量

		if (tUser.total >= 6) { //成为大使的条件之一，使者数量大于等于6人
			newLevel = 2 //大师
		}
		if (tUser.total >= 9) { //成为天使的条件之一，使者数量大于等于9人
			let dtotal = await userTable.where({
				inviter_uid: id,
				newLevel: 2
			}).count() //查询直接推荐的使者数量
			if (dtotal.total >= 3) { //团队大使大于等于3
				newLevel = 3 //成为天使
			}

		}
		//  if (tUser.total >= 9) { //成为联合创始人的条件之一
		// 	let dtotal = await userTable.where({
		// 		inviter_uid: id,
		// 		newLevel: 3
		// 	}).count() //查询直接推荐的使者数量
		// 	if (dtotal.total >= 9) { //团队大使大于等于6
		// 		newLevel = 4 //成为联合创始人
		// 	}
		// }

		if (level >= newLevel) { //如果当前层级大于新层级，使用当前层级
			newLevel = level
		}
		return newLevel


	} catch (e) {
		console.log("setUpUser.catch====>>>", e);
	}
}


/**
 * 更新用户身份
 * @param {data} 用户信息数组   
 */
async function upLevel(data) {
	try {
		if (data.length == 0) {
			return true
		}
		for (let i = 0; i < data.length; i++) {
			let id = data[i].id
			console.log("upLevel======>>>id+++", id, data[i])
			delete data[i].id
			await db.collection('uni-id-users').doc(id).update(data[i])
		}
		return true
	} catch (e) {
		console.log("upLevel.catch====>>>", e);
	}
}

/**
 * 设置分润
 * @param {id} 购买人id
 * @param {inviterIds} 推荐人 数组
 * @param {order_no} 购买订单编号
 */
async function setProfit({
	id,
	inviterIds,
	order_no
} = {}) {
	try {
		await setProfitDivvy({
			id,
			order_no
		}) //设置分红

		let zProfit = [] //推荐奖励明细
		if (inviterIds.length == 0) { //如果没有推荐人，直接返回，不存在管理奖
			return
		}

		let level = await getUserLevel(inviterIds[0]) //查询直接推介人的身份等级

		if (level > 0) { //存在直接推荐人，并且使者身份以上，直接推荐奖励建立到有效分红明细中，即幸福值
			db.collection("wolf-profit-divvy").add({
				uid: id, //来源
				pid: inviterIds[0], //获利人
				order_no: order_no,
				price: 30000,
				commit: "直接推荐奖励",
				type: 1,
				profit_price: 0,
				create_time: nowTime
			})
		}



		// 管理奖级差  100 200 300 
		let arr = []
		let arrUsers = await getUsersInfo(inviterIds[0], 0, arr) //查询所有等级数组
		let end_price = 0
		for (var i = 0; i < arrUsers.length; i++) {
			let price = 0
			let newLevel = arrUsers[i].newLevel || 0
			if (newLevel > 3) {
				newLevel = 3
			}

			let y_price = 10000 * newLevel //当前等级应分金额
			price = y_price - end_price //当前等级应分金额 - 已分金额
			end_price = price + end_price //设置已分金额的数量

			zProfit.push({
				uid: id, //来源
				pid: arrUsers[i]._id, //获利人
				orderid: order_no,
				price: price,
				commit: "管理奖励",
				type: 1,
				create_time: nowTime
			})
			// if (newLevel == 1) { //推荐人是使者的，就看有没有已经推荐了3个使者，有就给奖励，没有就不给奖励
			// 	let tUser = await userTable.where({
			// 		'inviter_uid.0': arrUsers[i]._id,
			// 		newLevel: 1
			// 	}).count() //查询直接推荐的使者数量

			// 	if (tUser.total >= 3) { //直接推荐使者的数量大于等于3
			// 		zProfit.push({
			// 			uid: id, //来源
			// 			pid: arrUsers[i]._id, //获利人
			// 			orderid: order_no,
			// 			price: price,
			// 			commit: "管理奖励",
			// 			type: 1,
			// 			create_time: nowTime
			// 		})
			// 	}
			// }
			// if (newLevel > 1) { //不是使者，直接发放奖励
			// 	zProfit.push({
			// 		uid: id, //来源
			// 		pid: arrUsers[i]._id, //获利人
			// 		orderid: order_no,
			// 		price: price,
			// 		commit: "管理奖励",
			// 		type: 1,
			// 		create_time: nowTime
			// 	})
			// }

		}
		console.log("zProfit==========>>>>>", zProfit);
		
		await setUserOrder(zProfit) //增加奖励明细及更新用户可提现金额
	} catch (e) {
		console.log("setProfit.catch=====>", e);
	}

}
/**
 * 递归查询上级推荐人的身份及信息
 * @@param {string}  id 身份ID
 * @@param {Number}  level 身份等级 
 * @param {Array}  身份数组，初始数组是传递过来的用户本身
 * @@return {Array} 包含各个等级用户身份的ID
 **/
async function getUsersInfo(id, level, arr) {
	if (level >= 3 || !id) { //如果用户的身份已经是天使，直接返回,或者不存在ID
		return arr
	}
	try {
		let userInfo = await userTable.doc(id).field({
			newLevel: true,
			inviter_uid: true,
			_id: true
		}).get()
		console.log("getUsersInfo=====>>>userInfo====>", userInfo, id);
		let dataIds = userInfo.data[0].inviter_uid || []
		let newLevel = userInfo.data[0].newLevel || 0
		if (newLevel > level) { //如果查到更高等级，返回更高等级信息
			if (newLevel == 1) { //身份是使者的，就看有没有已经直接推荐了3个使者，有就给奖励，没有就不给奖励
				let tUser = await userTable.where({
					'inviter_uid.0': id,
					newLevel: 1
				}).count() //查询直接推荐的使者数量
				if (tUser.total >= 3) { //直接推荐使者的数量大于等于3,将直接推荐人加入奖励推荐列表，查找下一个更高等级
					arr.push(userInfo.data[0])
				}else{
					newLevel = 0 //将等级设置成普通，继续查找下一个使者及以上身份
				}
			}else if(newLevel > 1){ //身份大于1，直接奖励
				arr.push(userInfo.data[0])
			}
		}

		if (dataIds.length == 0) { //没有推荐人，直接返回
			return arr
		}
		await getUsersInfo(dataIds[0], newLevel, arr) //没有查到更高等级，并且又存在推荐人，继续查找

		return arr
	} catch (e) {
		console.log("getUsersInfo.catch=====>", e);
	}
}




/**
 * 设置分润订单记录
 **/
async function setProfitDivvy({
	id,
	order_no
} = {}) {
	try {
		let res = await db.collection("wolf-profit-divvy").where({
			profit_price: $.lte(270000),
			type: 1
		}).field({
			_id: true,
			pid: true
		}).get()
		let data = res.data || []
		if (data.length == 0) { //没有有效记录 直接返回
			return
		}
		let len = data.length
		let price = Math.floor(30000 / len)
		if (price <= 0) { //分红金额小于1分 退出
			return
		}
		let arrLog = [] //分红记录
		let userIds = [] //分红人
		for (var i = 0; i < data.length; i++) {
			arrLog.push({
				profit_id: data[i]._id,
				price: price,
				order_no: order_no,
				uid: id,
				pid: data[i].pid,
				commit: "有效幸福值分红",
				create_time: nowTime
			})
			userIds.push(data[i].pid)
		}


		await db.collection("wolf-profit-divvy-log").add(arrLog) //数据库增加记录

		for (var i = 0; i < userIds.length; i++) { //异步更新数据库，用户的可提现金额，不统一更新，是因为有重复的用户
			db.collection("uni-id-users").doc(userIds[i]).update({
				money: $.inc(price),
				total_money: $.inc(price)
			})
		}
		// await db.collection("uni-id-users").where({ //更新用户可提现余额
		// 	_id: $.in(userIds)
		// }).update({
		// 	money: $.inc(price),
		// 	total_money: $.inc(price)
		// })

		await db.collection("wolf-profit-divvy").where({ //增加累计分红金额
			profit_price: $.lte(270000),
			type: 1
		}).update({
			profit_price: $.inc(price)
		})


	} catch (e) {
		console.log("setProfitDivvy.catch===>", e);
	}
}

/**
 * 设置分润明细，及增加用户可提现金额
 **/
async function setUserOrder(data) {
	try {
		console.log("setUserOrder++++++", data)
		if (data.length == 0) {
			return true
		}
		for (let i = 0; i < data.length; i++) {
			await db.collection('uni-id-users').doc(data[i].pid).update({
				money: $.inc(data[i].price),
				total_money: $.inc(data[i].price)
			})
		}
		console.log("dataOrder++", data)
		return await db.collection("wolf-profit-order").add(data)
	} catch (e) {
		console.log("setUserOrder.catch======>>>", e);
	}
}


/**
 * 查询会员身份等级
 * @param {id} 用户ID 
 **/
async function getUserLevel(id) {
	try {
		let res = await userTable.doc(id).field({
			newLevel: true
		}).get()
		return res.data[0].newLevel || 0
	} catch (e) {
		console.log('getUserLevel.catch=========>>>', e);
	}
}

module.exports = {
	setNewLevel
}